/**
 * 抽象类
 * 抽象方法是只有方法签名，没有方法实现的方法。
 * <p>
 * 抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法。
 * 抽象方法和抽象类的规则如下。
 * ➢ 抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。
 * ➢ 抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。
 * 即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。
 * ➢ 抽象类可以包含成员变量、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类（接口、枚举）5种成分。
 * 抽象类的构造器不能用于创建实例，主要是用于被其子类调用。
 * ➢ 含有抽象方法的类（包括直接定义了一个抽象方法；或继承了一个抽象父类，但没有完全实现父类包含的抽象方法；
 * 或实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义成抽象类。
 */

// Shape类里包含了两个抽象方法：calPerimeter()和getType()，所以这个Shape类只能被定义成抽象类。
// Shape类里既包含了初始化块，也包含了构造器，这些都不是在创建Shape对象时被调用的，而是在创建其子类的实例时被调用。
abstract class Shape {
    {
        System.out.println("执行Shape的初始化块...");
    }

    private String color;

    public abstract double calPerimeter();

    public abstract String getType();

    public Shape() {
    }

    public Shape(String color) {
        System.out.println("执行Shape的构造器...");
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}


// 下面定义一个三角形类，三角形类被定义成普通类，因此必须实现Shape类里的所有抽象方法。
class Triangle extends Shape {
    private double a;
    private double b;
    private double c;

    public Triangle(String color, double a, double b, double c) {
        super(color);
        setSides(a, b, c);
    }

    public void setSides(double a, double b, double c) {
        if (a >= b + c || b >= a + c || c >= a + b) {
            System.out.println("三角形两边之和必须大于第三边");
            return;
        }
        this.a = a;
        this.b = b;
        this.c = c;
    }

    @Override
    public double calPerimeter() {
        return a + b + c;
    }

    @Override
    public String getType() {
        return "三角形";
    }
}

//上面的Triangle类继承了Shape抽象类，并实现了Shape类中两个抽象方法，是一个普通类，因此可以创建Triangle类的实例，
// 可以让一个Shape类型的引用变量指向Triangle对象。
// 下面再定义一个Circle普通类，Circle类也是Shape类的一个子类。
class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double calPerimeter() {
        return 2 * Math.PI * radius;
    }

    @Override
    public String getType() {
        return getColor() + "圆形";
    }

    public static void test() {
        Shape s1 = new Triangle("黑色", 3, 4, 5);
        Shape s2 = new Circle("黄色", 3);
        System.out.println(s1.getType());
        System.out.println(s1.calPerimeter());
        System.out.println(s2.getType());
        System.out.println(s2.calPerimeter());

    }
}

/**
 * 利用抽象类和抽象方法的优势，可以更好地发挥多态的优势，使得程序更加灵活。当使用abstract修饰类时，表明这个类只能被继承；
 * 当使用abstract修饰方法时，表明这个方法必须由子类提供实现（即重写）。
 * 而final修饰的类不能被继承，final修饰的方法不能被重写。
 * 因此final和abstract永远不能同时使用。
 * <p>
 * 注意：abstract不能用于修饰成员变量，不能用于修饰局部变量，即没有抽象变量、没有抽象成员变量等说法；
 * abstract也不能用于修饰构造器，没有抽象构造器，抽象类里定义的构造器只能是普通构造器。
 * static和abstract不能同时修饰某个方法，即没有所谓的类抽象方法。
 * 注意：static和abstract并不是绝对互斥的，static和abstract虽然不能同时修饰某个方法，但它们可以同时修饰内部类。
 * 注意：abstract关键字修饰的方法必须被其子类重写才有意义，否则这个方法将永远不会有方法体，
 * 因此abstract方法不能定义为private访问权限，即private和abstract不能同时修饰方法。
 */

/**
 * 抽象类的作用
 * 抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，
 * 子类在抽象类的基础上进行扩展、改造，但子类总体上会大致保留抽象类的行为方式。
 * <p>
 * 模板模式在面向对象的软件中很常用，其原理简单，实现也很简单。
 * 下面是使用模板模式的一些简单规则。
 * ➢ 抽象父类可以只定义需要使用的某些方法，把不能实现的部分抽象成抽象方法，留给其子类去实现。
 * ➢ 父类中可能包含需要调用其他系列方法的方法，这些被调方法既可以由父类实现，也可以由其子类实现。
 * 父类里提供的方法只是定义了一个通用算法，其实现也许并不完全由自身实现，而必须依赖于其子类的辅助。
 */

public class AbstractTest {
    public static void main(String[] args) {
        Circle.test();
    }
}
